//在创建对象时，能否创建一个与已有对象一模一样的新对象呢？
//拷贝构造函数:只是单个形参，该形参是对本类类型对象的引用（一般常用const修饰）
//在用已存在的类类型对象创建新对象时由编译器自动调用

//特征：
//1.拷贝构造函数是构造函数的一种重载形式
//2.拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用
//3.若未显示定义，编译器会生成默认的拷贝构造函数。
//默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝

#include <iostream>
#include <assert.h>
using namespace std;

class Stack
{
public:
	Stack(int defaultcapacity = 4)
	{
		cout << "Stack" << endl;
		a = (int*)malloc(sizeof(int) * defaultcapacity);
		if (a == nullptr)
		{
			perror("malloc failed");
			return;
		}
		top = 0;
		capacity = defaultcapacity;
	}

	void Push(int x);
	void Pop();
	void Destroy();
	int Top();
	int Size();
	bool Empty();
	void Print();
private:
	int* a;
	int top;
	int capacity;
};

class Queue
{
private:
	Stack _pushst;
	Stack _popst;
};

class Date
{
public:
	Date(int year = 1,int month = 1,int day = 1)
	{
		_day = day;
		_month = month;
		_year = year;
	}

	//构造同类型的对象
	Date(Date d)
	{
		_year = d._year;
		_month = d._month;
		_year = d._year;
	}
	//引用
	Date(Date& d)    // Date(const Date& d)  一般还要加上const，防止书写错误使变量被修改
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2025, 6, 18);
	Date d2(d1);

	return 0;
}






void Stack::Push(int x)
{
	if (top == capacity)
	{
		int* tmp = (int*)realloc(a, sizeof(int) * capacity * 2);
		if (tmp == nullptr)
		{
			perror("realloc failed");
			return;
		}
		a = tmp;
		capacity *= 2;
	}

	a[top] = x;
	top++;
}

void Stack::Pop()
{
	assert(!Empty());
	top--;
}

bool Stack::Empty()
{
	return top == 0;
}

int Stack::Top()
{
	return a[top - 1];
}

int Stack::Size()
{
	return top;
}

void Stack::Destroy()
{
	free(a);
	a = nullptr;
	top = 0;
	capacity = 0;
}

void Stack::Print()
{
	for (int i = 0; i < top; i++)
	{
		cout << a[i] << " ";
	}
	cout << " " << endl;
	cout << "打印完毕." << endl;
}